package com.example.demo.excel1;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * @author yongsheng.he
 * @describe 日期工具类：用于日期相关的处理
 * @date 2018/07/01 11:58
 */
public class DateUtil {
	// Grace style
	public static final String PATTERN_GRACE = "yyyy/MM/dd HH:mm:ss";
	public static final String PATTERN_GRACE_NORMAL = "yyyy/MM/dd HH:mm";
	public static final String PATTERN_GRACE_SIMPLE = "yyyy/MM/dd";
	
	// Classical style
	public static final String PATTERN_CLASSICAL = "yyyy-MM-dd HH:mm:ss";
	public static final String PATTERN_CLASSICAL_NORMAL = "yyyy-MM-dd HH:mm";
	public static final String PATTERN_CLASSICAL_SIMPLE = "yyyy-MM-dd";
	
	private DateUtil() {
		// Cannot be instantiated
	}
	
	/**
	 * 根据默认格式将指定字符串解析成日期
	 *
	 * @param str 指定字符串
	 *
	 * @return 返回解析后的日期
	 */
	public static Date parse(String str) {
		return parse(str, PATTERN_CLASSICAL);
	}
	
	/**
	 * 根据指定格式将指定字符串解析成日期
	 *
	 * @param str     指定日期
	 * @param pattern 指定格式
	 *
	 * @return 返回解析后的日期
	 */
	public static Date parse(String str, String pattern) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		try {
			return sdf.parse(str);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 根据默认格式将日期转格式化成字符串
	 *
	 * @param date 指定日期
	 *
	 * @return 返回格式化后的字符串
	 */
	public static String format(Date date) {
		return format(date, PATTERN_CLASSICAL);
	}
	
	/**
	 * 根据指定格式将指定日期格式化成字符串
	 *
	 * @param date    指定日期
	 * @param pattern 指定格式
	 *
	 * @return 返回格式化后的字符串
	 */
	public static String format(Date date, String pattern) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		return sdf.format(date);
	}
	
	/**
	 * 获取时间date1与date2相差的秒数
	 *
	 * @param date1 起始时间
	 * @param date2 结束时间
	 *
	 * @return 返回相差的秒数
	 */
	public static int getOffsetSeconds(Date date1, Date date2) {
		int seconds = (int) ((date2.getTime() - date1.getTime()) / 1000);
		return seconds;
	}
	
	/**
	 * 获取时间date1与date2相差的分钟数
	 *
	 * @param date1 起始时间
	 * @param date2 结束时间
	 *
	 * @return 返回相差的分钟数
	 */
	public static int getOffsetMinutes(Date date1, Date date2) {
		return getOffsetSeconds(date1, date2) / 60;
	}
	
	/**
	 * 获取时间date1与date2相差的小时数
	 *
	 * @param date1 起始时间
	 * @param date2 结束时间
	 *
	 * @return 返回相差的小时数
	 */
	public static int getOffsetHours(Date date1, Date date2) {
		return getOffsetMinutes(date1, date2) / 60;
	}
	
	/**
	 * 获取时间date1与date2相差的天数数
	 *
	 * @param date1 起始时间
	 * @param date2 结束时间
	 *
	 * @return 返回相差的天数
	 */
	public static int getOffsetDays(Date date1, Date date2) {
		return getOffsetHours(date1, date2) / 24;
	}
	
	/**
	 * 获取时间date1与date2相差的周数
	 *
	 * @param date1 起始时间
	 * @param date2 结束时间
	 *
	 * @return 返回相差的周数
	 */
	public static int getOffsetWeeks(Date date1, Date date2) {
		return getOffsetDays(date1, date2) / 7;
	}
	
	/**
	 * 获取重置指定日期的时分秒后的时间
	 *
	 * @param date   指定日期
	 * @param hour   指定小时
	 * @param minute 指定分钟
	 * @param second 指定秒
	 *
	 * @return 返回重置时分秒后的时间
	 */
	public static Date getResetTime(Date date, int hour, int minute, int second) {
		Calendar cal = Calendar.getInstance();
		if (date != null) {
			cal.setTime(date);
		}
		cal.set(Calendar.HOUR_OF_DAY, hour);
		cal.set(Calendar.SECOND, minute);
		cal.set(Calendar.MINUTE, second);
		return cal.getTime();
	}
	
	/**
	 * 返回指定日期的起始时间
	 *
	 * @param date 指定日期（例如2014-08-01）
	 *
	 * @return 返回起始时间（例如2014-08-01 00:00:00）
	 */
	public static Date getIntegralStartTime(Date date) {
		return getResetTime(date, 0, 0, 0);
	}
	
	/**
	 * 返回指定日期的结束时间
	 *
	 * @param date 指定日期（例如2014-08-01）
	 *
	 * @return 返回结束时间（例如2014-08-01 23:59:59）
	 */
	public static Date getIntegralEndTime(Date date) {
		return getResetTime(date, 23, 59, 59);
	}
	
	/**
	 * 获取指定日期累加年月日后的时间
	 *
	 * @param date  指定日期
	 * @param year  指定年数
	 * @param month 指定月数
	 * @param day   指定天数
	 *
	 * @return 返回累加年月日后的时间
	 */
	public static Date rollDate(Date date, int year, int month, int day) {
		Calendar cal = Calendar.getInstance();
		if (date != null) {
			cal.setTime(date);
		}
		cal.add(Calendar.YEAR, year);
		cal.add(Calendar.MONTH, month);
		cal.add(Calendar.DAY_OF_MONTH, day);
		return cal.getTime();
	}
	
	/**
	 * 获取指定日期累加指定月数后的时间
	 *
	 * @param date  指定日期
	 * @param month 指定月数
	 *
	 * @return 返回累加月数后的时间
	 */
	public static Date rollMonth(Date date, int month) {
		return rollDate(date, 0, month, 0);
	}
	
	/**
	 * 获取指定日期累加指定天数后的时间
	 *
	 * @param date 指定日期
	 * @param day  指定天数
	 *
	 * @return 返回累加天数后的时间
	 */
	public static Date rollDay(Date date, int day) {
		return rollDate(date, 0, 0, day);
	}
	
	/**
	 * 计算指定日期所在月份的天数
	 *
	 * @param date 指定日期
	 *
	 * @return 返回所在月份的天数
	 */
	public static int getDayOfMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		if (date != null) {
			cal.setTime(date);
		}
		int dayOfMonth = cal.getActualMaximum(Calendar.DATE);
		return dayOfMonth;
	}
	
	/**
	 * 获取当月第一天的起始时间，例如2014-08-01 00:00:00
	 *
	 * @return 返回当月第一天的起始时间
	 */
	public static Date getMonthStartTime() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_MONTH, 1);
		return getIntegralStartTime(cal.getTime());
	}
	
	/**
	 * 获取当月最后一天的结束时间，例如2014-08-31 23:59:59
	 *
	 * @return 返回当月最后一天的结束时间
	 */
	public static Date getMonthEndTime() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_MONTH, getDayOfMonth(cal.getTime()));
		return getIntegralEndTime(cal.getTime());
	}
	
	/**
	 * 获取上个月第一天的起始时间，例如2014-07-01 00:00:00
	 *
	 * @return 返回上个月第一天的起始时间
	 */
	public static Date getLastMonthStartTime() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.MONTH, - 1);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		return getIntegralStartTime(cal.getTime());
	}
	
	/**
	 * 获取上个月最后一天的结束时间，例如2014-07-31 23:59:59
	 *
	 * @return 返回上个月最后一天的结束时间
	 */
	public static Date getLastMonthEndTime() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.MONTH, - 1);
		cal.set(Calendar.DAY_OF_MONTH, getDayOfMonth(cal.getTime()));
		return getIntegralEndTime(cal.getTime());
	}
	
	/**
	 * 获取下个月第一天的起始时间，例如2014-09-01 00:00:00
	 *
	 * @return 返回下个月第一天的起始时间
	 */
	public static Date getNextMonthStartTime() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.MONTH, 1);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		return getIntegralStartTime(cal.getTime());
	}
	
	/**
	 * 获取下个月最后一天的结束时间，例如2014-09-30 23:59:59
	 *
	 * @return 返回下个月最后一天的结束时间
	 */
	public static Date getNextMonthEndTime() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.MONTH, 1);
		cal.set(Calendar.DAY_OF_MONTH, getDayOfMonth(cal.getTime()));
		return getIntegralEndTime(cal.getTime());
	}
	
	/**
	 * 获取当前季度第一天的起始时间
	 *
	 * @return 返回当前季度第一天的起始时间
	 */
	public static Date getQuarterStartTime() {
		Calendar cal = Calendar.getInstance();
		int month = cal.get(Calendar.MONTH);
		if (month < 3) {
			cal.set(Calendar.MONTH, 0);
		} else if (month < 6) {
			cal.set(Calendar.MONTH, 3);
		} else if (month < 9) {
			cal.set(Calendar.MONTH, 6);
		} else {
			cal.set(Calendar.MONTH, 9);
		}
		cal.set(Calendar.DAY_OF_MONTH, 1);
		return getIntegralStartTime(cal.getTime());
	}
	
	/**
	 * 获取当前季度最后一天的结束时间
	 *
	 * @return 返回当前季度最后一天的结束时间
	 */
	public static Date getQuarterEndTime() {
		Calendar cal = Calendar.getInstance();
		int month = cal.get(Calendar.MONTH);
		if (month < 3) {
			cal.set(Calendar.MONTH, 2);
		} else if (month < 6) {
			cal.set(Calendar.MONTH, 5);
		} else if (month < 9) {
			cal.set(Calendar.MONTH, 8);
		} else {
			cal.set(Calendar.MONTH, 11);
		}
		cal.set(Calendar.DAY_OF_MONTH, getDayOfMonth(cal.getTime()));
		return getIntegralEndTime(cal.getTime());
	}
	
	/**
	 * 获取前一个工作日
	 *
	 * @return 返回前一个工作日
	 */
	public static Date getPrevWorkday() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DAY_OF_MONTH, - 1);
		if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
			cal.add(Calendar.DAY_OF_MONTH, - 2);
		}
		if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {
			cal.add(Calendar.DAY_OF_MONTH, - 1);
		}
		return getIntegralStartTime(cal.getTime());
	}
	
	/**
	 * 获取下一个工作日
	 *
	 * @return 返回下个工作日
	 */
	public static Date getNextWorkday() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DAY_OF_MONTH, 1);
		if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {
			cal.add(Calendar.DAY_OF_MONTH, 2);
		}
		if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
			cal.add(Calendar.DAY_OF_MONTH, 1);
		}
		return getIntegralStartTime(cal.getTime());
	}
	
	/**
	 * 获取当周的第一个工作日
	 *
	 * @return 返回第一个工作日
	 */
	public static Date getFirstWorkday() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
		return getIntegralStartTime(cal.getTime());
	}
	
	/**
	 * 获取当周的最后一个工作日
	 *
	 * @return 返回最后一个工作日
	 */
	public static Date getLastWorkday() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
		return getIntegralStartTime(cal.getTime());
	}
	
	/**
	 * 判断指定日期是否是工作日
	 *
	 * @param date 指定日期
	 *
	 * @return 如果是工作日返回true，否则返回false
	 */
	public static boolean isWorkday(Date date) {
		Calendar cal = Calendar.getInstance();
		if (date != null) {
			cal.setTime(date);
		}
		int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
		return ! (dayOfWeek == Calendar.SATURDAY || dayOfWeek == Calendar.SUNDAY);
	}
	
	/**
	 * 获取指定日期是星期几
	 *
	 * @param date 指定日期
	 *
	 * @return 返回星期几的描述
	 */
	public static String getWeekdayDesc(Date date) {
		final String[] weeks = new String[] {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
		Calendar cal = Calendar.getInstance();
		if (date != null) {
			cal.setTime(date);
		}
		return weeks[cal.get(Calendar.DAY_OF_WEEK) - 1];
	}
	
	/**
	 * 获取指定日期距离当前时间的时间差描述（如3小时前、1天前）
	 *
	 * @param date 指定日期
	 *
	 * @return 返回时间差的描述
	 */
	public static String getTimeOffsetDesc(Date date) {
		int seconds = getOffsetSeconds(date, new Date());
		if (Math.abs(seconds) < 60) {
			return Math.abs(seconds) + "秒" + (seconds > 0 ? "前" : "后");
		}
		int minutes = seconds / 60;
		if (Math.abs(minutes) < 60) {
			return Math.abs(minutes) + "分钟" + (minutes > 0 ? "前" : "后");
		}
		int hours = minutes / 60;
		if (Math.abs(hours) < 60) {
			return Math.abs(hours) + "小时" + (hours > 0 ? "前" : "后");
		}
		int days = hours / 24;
		if (Math.abs(days) < 7) {
			return Math.abs(days) + "天" + (days > 0 ? "前" : "后");
		}
		int weeks = days / 7;
		if (Math.abs(weeks) < 5) {
			return Math.abs(weeks) + "周" + (weeks > 0 ? "前" : "后");
		}
		int monthes = days / 30;
		if (Math.abs(monthes) < 12) {
			return Math.abs(monthes) + "个月" + (monthes > 0 ? "前" : "后");
		}
		int years = monthes / 12;
		return Math.abs(years) + "年" + (years > 0 ? "前" : "后");
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Date date = new Date();
		Date date1 = rollDay(date, - 20);
		Date date2 = rollMonth(date, - 3);
		System.out.println(format(date1));
		System.out.println(format(date2));
		System.out.println(getTimeOffsetDesc(date1));
		System.out.println(getTimeOffsetDesc(date2));
		System.out.println(getNextMonthStartTime());
		System.out.println(getNextMonthEndTime());
		System.out.println(getPrevWorkday());
		System.out.println(getNextWorkday());
		System.out.println(getQuarterStartTime());
		System.out.println(getQuarterEndTime());
		System.out.println(getFirstWorkday());
		System.out.println(getLastWorkday());
		System.out.println(getWeekdayDesc(null));
	}
}
